/* *******************************************************************
 * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
 * All rights reserved.
 * This program and the accompanying materials are made available
 * under the terms of the Eclipse Public License v 2.0
 * which accompanies this distribution and is available at
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.txt
 *
 * Contributors:
 *     PARC     initial implementation
 * ******************************************************************/

package org.aspectj.ajdt.internal.compiler.batch;

import java.io.File;
import java.io.IOException;
import java.util.*;

import junit.framework.TestCase;

import org.aspectj.ajdt.ajc.AjdtCommand;
import org.aspectj.ajdt.ajc.Constants;
import org.aspectj.bridge.ICommand;
import org.aspectj.bridge.IMessage;
import org.aspectj.bridge.IMessageHandler;
import org.aspectj.bridge.IMessageHolder;
import org.aspectj.bridge.MessageHandler;
import org.aspectj.testing.util.TestUtil;
import org.aspectj.util.LangUtil;
import org.aspectj.weaver.bcel.LazyClassGen;

public abstract class CommandTestCase extends TestCase {

	/**
	 * Constructor for CommandTestCase.
	 *
	 * @param name
	 */
	public CommandTestCase(String name) {
		super(name);
	}

	public static final int[] NO_ERRORS = new int[0];
	public static final int[] TOP_ERROR = new int[0];

	private File sandbox;

	public void checkCompile(String source, int[] expectedErrors) {
		checkCompile(source, new String[0], expectedErrors, getSandboxName());
	}

	protected void runMain(String className) {
		TestUtil.runMain(getSandboxName(), className);
	}

	public void checkCompile(String source, String[] extraArgs, int[] expectedErrors) {
		checkCompile(source,extraArgs,expectedErrors,getSandboxName());
	}

	public static void checkCompile(String source, String[] extraArgs, int[] expectedErrors, String sandboxName) {
		List<String> args = new ArrayList<>();
		args.add("-verbose");

		args.add("-d");
		args.add(sandboxName);

		args.add("-classpath");

		args.add(getRuntimeClasspath() + File.pathSeparator + "../lib/junit/junit.jar");

		args.add("-g"); // XXX need this to get sourcefile and line numbers, shouldn't

		Collections.addAll(args, extraArgs);

		args.add(Constants.TESTDATA_PATH + "/" + source);

		runCompiler(args, expectedErrors);
	}

	public void testEmptyForAntJUnitSupport() {
	}

	public void checkMultipleCompile(String source) throws InterruptedException {
		List<String> args = new ArrayList<>();
		args.add("-verbose");

		args.add("-d");
		args.add(getSandboxName());

		args.add("-classpath");
		args.add(getRuntimeClasspath());

		args.add(Constants.TESTDATA_PATH + "/" + source);

		ICommand compiler = runCompiler(args, NO_ERRORS);
		Thread.sleep(100);

		rerunCompiler(compiler);
	}

	public void rerunCompiler(ICommand command) {
		MessageHandler myHandler = new MessageHandler();
		// List recompiledFiles = new ArrayList();
		if (!command.repeatCommand(myHandler)) {
			assertTrue("recompile failed", false);
		}
		assertEquals(0, myHandler.numMessages(IMessage.ERROR, true));
	}

	public static ICommand runCompiler(List<String> args, int[] expectedErrors) {
		ICommand command = new AjdtCommand();
		MessageHandler myHandler = new MessageHandler();
		myHandler.setInterceptor(org.aspectj.tools.ajc.Main.MessagePrinter.TERSE);
		boolean result = command.runCommand((String[]) args.toArray(new String[0]), myHandler);
		System.out.println("result: " + result);
		// System.out.println("errors: " + Arrays.asList(myHandler.getErrors()));
		// System.out.println("warnings: " + Arrays.asList(myHandler.getWarnings()));

		int nErrors = myHandler.numMessages(IMessage.ERROR, IMessageHolder.EQUAL);
		if (expectedErrors == NO_ERRORS) {
			if (0 != nErrors) {
				String s = "" + Arrays.asList(myHandler.getErrors());
				assertTrue("unexpected errors: " + s, false);
			}
		} else if (expectedErrors == TOP_ERROR) { // ?? what is this?
			assertTrue("expected error", nErrors > 0);
		} else {
			List errors = new ArrayList(Arrays.asList(myHandler.getErrors()));
			for (int line : expectedErrors) {
				boolean found = false;
				for (Iterator iter = errors.iterator(); iter.hasNext(); ) {
					IMessage m = (IMessage) iter.next();
					if (m.getSourceLocation() != null && m.getSourceLocation().getLine() == line) {
						found = true;
						iter.remove();
					}
				}
				assertTrue("didn't find error on line " + line, found);
			}
			if (errors.size() > 0) {
				assertTrue("didn't expect errors: " + errors, false);
			}
		}
		return command;
	}

	public static void printGenerated(String path, String name) throws IOException {
		String fullpath = Constants.TESTDATA_PATH + "/" + path;
		LazyClassGen.disassemble(fullpath, name, System.out);
	}

	/** incremental test case adapter to JUnit */
	public class IncCase extends IncrementalCase {
		protected void fail(IMessageHandler handler, String mssg) {
			assertTrue(mssg, false);
		}

		protected void message(IMessage.Kind kind, String mssg, IMessageHandler handler) {
			if ((kind == IMessage.FAIL) || (kind == IMessage.ABORT)) {
				assertTrue(mssg, false);
			} else {
				System.err.println("IncCase " + kind + ": " + mssg); // XXX
			}
			super.message(kind, mssg, handler);
		}

	}

	/** get the location of the org.aspectj.lang & runtime classes */
	protected static String getRuntimeClasspath() {
		StringBuilder classpath = new StringBuilder();
		if (LangUtil.isVMGreaterOrEqual(9)) {
			classpath.append(LangUtil.getJrtFsFilePath()).append(File.pathSeparator);
		}
		classpath.append(Constants.aspectjrtClasspath());
		return classpath.toString();
	}

	protected String getSandboxName() {
		return sandbox.getAbsolutePath();
	}

	protected void setUp() throws Exception {
		super.setUp();

		sandbox = TestUtil.createEmptySandbox();
	}

}
